#!/usr/bin/python3
# -*- coding: iso-8859-1 -*-

"""
Copyright Pascal KREZEL Janvier 2012

pascal.krezel@gmail.com

TUBA est un programme informatique servant à modéliser rapidement
des tuyauteries à l'aide de SaloméMéca via un langage de commandes nommé PKL.

Ce logiciel est régi par la licence CeCILL soumise au droit français et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
sur le site "http://www.cecill.info".

En contrepartie de l'accessibilité au code source et des droits de copie,
de modification et de redistribution accordés par cette licence, il n'est
offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
seule une responsabilité restreinte pèse sur l'auteur du programme,  le
titulaire des droits patrimoniaux et les concédants successifs.

A cet égard  l'attention de l'utilisateur est attirée sur les risques
associés au chargement,  à l'utilisation,  à la modification et/ou au
développement et à la reproduction du logiciel par l'utilisateur étant 
donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
manipuler et qui le réserve donc à des développeurs et des professionnels
avertis possédant  des  connaissances  informatiques approfondies.  Les
utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
logiciel à leurs besoins dans des conditions permettant d'assurer la
sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 

Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
pris connaissance de la licence CeCILL, et que vous en avez accepté les
termes.


    
"""
import math
from TUBA_fonctions import *

try:
    from TUBA_Sections import LesSections
except: pass

eps=1e-6
Kpiq_c=1.5            # Coefficients pour la représentation volumique d'un piquage
Kpiq_p=1.5

KVpiq_c=1.2            # Coefficients pour la représentation volumique d'un piquage
KVpiq_p=1.2

# Dico des matériaux prédéfinis (! : mettre le nom en MAJUSCULE!)
#                    E       nu      rho     alpha   lamb    rhoCp
DicMat={  
	"ACIER":	[   200,    0.3,    8.0,    10.0,   50.0,   4.0    	], #Valeurs simplifiées
	"RIGIDE":	[  20000,  0.3,    8.0,    10.9,   54.6,   3.71    	],
	"IMS":	        [     206,    0.29,    7.8,    10.9,   54.6,   3.71    	],
	"A42":	        [     204,    0.4,    7.8,    10.9,   54.6,   3.71    	]}

#---------------------------------------------------------------------------------------------------------------
def VerifierNom(nom):
    pass           

#---------------------------------------------------------------------------------------------------------------
def VerifierSupport(obj,Cd,A,nom):

    k=len(A)
    
    
    if not(k==0 or k==6):
        AfficherErreur( [  " 4 Façons d'utiliser " + Cd +" : ",
                            "          1 - "+Cd,
                            "          2 - "+Cd+":nomP",
                            "          3 - "+Cd+":nomP,nomSupport",       
                            "          4 - "+Cd+"= KX,KY,KZ,KRX,KRY,KRZ:nom" ])                
        
    if Cd not in obj.LesSupports:
        obj.Ajouter_DDL(Cd)
    

    # Les supports ne sont pas à prendre en compte comme commande pour le comptage
    # des commandes passées par P
    An=VectNum(A)
#---------------------------------------------------------------------------------------------------------------
def VerifierSupport(obj,Cd,A,nom):
    

    k=len(A)
    if not(k==0 or k==1 or k==7):
        AfficherErreur( [  " 4 Façons d'utiliser " + Cd +" : ",
                            "          1 - "+Cd+"=L",
                            "          2 - "+Cd+"=L:nomP",
                            "          3 - "+Cd+"=L:nomP,nomSupport",       
                            "          4 - "+Cd+"=L,KX,KY,KZ,KRX,KRY,KRZ:nom",
                            "L : Largeur du support",
                            "Ki : les raideurs caractérisant le support"
                             ])                
        
    if Cd not in obj.LesSupports:
        obj.Ajouter_DDL(Cd)
    

    # Les supports ne sont pas à prendre en compte comme commande pour le comptage
    # des commandes passées par P
    An=VectNum(A)
#--------------------------------------------------------------------------------------------------------------
def Verifier_AngleP(obj,A,nom,lien):  
    nA = len(A)
    if nA != 1 :

        AfficherErreur([
        "AngleP = a",
        "a : angle de rotation de la section autour de la l'axe de la fibre neutre"
        ])


#--------------------------------------------------------------------------------------------------------------
def Verifier_Bud(obj,A,nom,lien):  
    nA = len(A)
    if nA != 2 or float(A[0])<0:

        AfficherErreur([    "Bxa = L,ad",
                            "L indique la distance entre le tuyau et le support",
                            "L >0",
                            "ad : angle dihédrique de torsion"])
#---------------------------------------------------------------------------------------------------------------
def Verifier_Bride(obj,A,nom,lien):
    nA = len(A)
    if nA != 2:
        AfficherErreur([    "Bride=L,m"])
    
    [L,m]=ConvNFloat(A,2)
    if L<0 or m<0 :
        AfficherErreur([    "Bride=L,m avec L et m >0"])    


#---------------------------------------------------------------------------------------------------------------
def Verifier_Bx(obj,A,nom,lien):
    VerifierSupport(obj,"Bx",A,nom)

#---------------------------------------------------------------------------------------------------------------
def Verifier_By(obj,A,nom,lien):
    VerifierSupport(obj,"By",A,nom)

#---------------------------------------------------------------------------------------------------------------
def Verifier_Bz(obj,A,nom,lien):
    VerifierSupport(obj,"Bz",A,nom)

#---------------------------------------------------------------------------------------------------------------
def Verifier_CB(obj,A,nom,lien):
    VerifierSupport(obj,"CB",A,nom)

#---------------------------------------------------------------------------------------------------------------
def Verifier_CG(obj,A,nom,lien):
    VerifierSupport(obj,"CG",A,nom)
 
#-------------------------------------------------------------------------------------------------------------
def Verifier_Ca(obj,A,nom,lien):

    nA=len(A)

    if nA != 3 :
        AfficherErreur([" Ca  = Rc,ac,ad:nom"])

    [rc,ac,ad] = VectNum(A)

    if rc < 0:
        AfficherErreur([ "Ca=rc,a,ad : Le rayon de courbure doit être positif!"])
    
    if ac < 0:
        AfficherErreur([  "Ca=rc,a,ad :L'angle de la courbure doit être positif!"])
        
    if ac > 90:
        AfficherErreur([  "Ca=rc,a,ad :L'angle de la courbure doit être inférieur à 90°"])
    

#-------------------------------------------------------------------------------
def Verifier_Calcul(obj,A,nom,lien):
    
    LesCas= [
        "MODES_PROPRES",
        "STATIQUE_LINEAIRE",
        "STATIQUE_LINEAIRE_CHARPENTE",
        "STATIQUE_LINEAIRE_FLEXIBILITE",
        "STATIQUE_NON_LINEAIRE",
        "DYNAMIQUE_PHYSIQUE",
        "DYNAMIQUE_MODALE",
        "ANALYSE_SISMIQUE",
#       "THERMOSTATIQUE_LINEAIRE"
#       "THERMOSTATIQUE_NON_LINEAIRE",
    ]

    if nom not in LesCas:
        AfficherErreur(LesCas)
    

#-------------------------------------------------------------------------------
def Verifier_Ci(obj,A,nom,lien):

    nA=len(A)
    

    if nA > 1 :
        AfficherErreur([ "Ci=R  ou Ci si R déjà défini"])

    if A!=[]:
        Rc = float(A[0])
        if Rc < eps:
            AfficherErreur([ "le rayon de courbure doit être positif!"])


#--------------------------------------------------------------------------------
def Verifier_CouleA(obj,A,nom,lien):

    nA=len(A)
    LTex=[ 
        " CouleA = ad1,ad2,ad2,Rp,ep,Ld,Le,Lh,dL,rc",
        " ad1 : angle dihédrique d'arrivée",
        " ad2 : angle dihédrique de la boucle",
        " ad3 : angle dihédrique de fin",
        " Rp : Rayon du piquage",
        " ep : épaisseur du piquage",
        " Ld : Longueur de déportement",
        " Le : Longueur d'espacement",
        " Lh : Longueur verticale max",
        " dL : Longueur entre entrée et sortie de boucle",
        " rc :  rayon de courbure" 
        ]
        
    if nA != 10 :
        AfficherErreur(LTex)
 
    [ad1,ad2,ad3,Rp,ep,Ld,Le,Lh,dL,rc]=A
    
    if 2.01*rc>Le:
        AfficherErreur(["Longueur d'espacement insuffisant!"])
        
#---------------------------------------------------------------------------------------------------------------
def Verifier_CouleB(obj,A,nom,lien):

    nA=len(A)
    LTex=[ 
        " CouleB = ad1,ad2,ad2,Rp,ep,Ld,Le,Lh,dL,rc",
        " ad1 : angle dihédrique d'arrivée",
        " ad2 : angle dihédrique de la boucle",
        " ad3 : angle dihédrique de fin",
        " Rp : Rayon du piquage",
        " ep : épaisseur du piquage",
        " Ld : Longueur de déportement",
        " Le : Longueur d'espacement",
        " Lh : Longueur verticale max",
        " dL : Longueur entre entrée et sortie de boucle",
        " rc :  rayon de courbure" 
        ]
        
    if nA != 10 :
        AfficherErreur(LTex)
 
    [ad1,ad2,ad3,Rp,ep,Ld,Le,Lh,dL,rc]=A
   
    if 2.01*rc>Le:
        AfficherErreur(["Longueur d'espacement insuffisant!"])
        
#---------------------------------------------------------------------------------------------------------------
def Verifier_CouleC(obj,A,nom,lien):

    nA=len(A)
    LTex=[ 
        " CouleC = ad1,ad2,ad2,Rp,ep,Ld,Le,Lh1,dL,rc",
        " ad1 : angle dihédrique d'arrivée",
        " ad2 : angle dihédrique de la boucle",
        " ad3 : angle dihédrique de fin",
        " Rp : Rayon du piquage",
        " ep : épaisseur du piquage",
        " Ld : Longueur de déportement",
        " Le : Longueur d'espacement",
        " Lh1 : Longueur verticale",
        " dL : Longueur entre entrée et sortie de boucle",
        " rc :  rayon de courbure" 
        ]
        
    if nA != 10 :
        AfficherErreur(LTex)
 
    [ad1,ad2,ad3,Rp,ep,Ld,Le,Lh,dL,rc]=A
    
    if 2.01*rc>Le:
        AfficherErreur(["Longueur d'espacement insuffisant!"])
        
 
#---------------------------------------------------------------------------------------------------------------
def Verifier_F_3D(obj,A,nom,lien):
    AfficherErreur(["F uniquement utilisable avec les éléments TUBE pour le moment!"])


#---------------------------------------------------------------------------------------------------------------
def Verifier_Fn1(obj,A,nom,lien):

    VerifierNom(nom)

    nA=len(A)
    
    if nA != 1 :
        AfficherErreur([ " Fn_ = A : nom, (nom facultatif)"])
        
#---------------------------------------------------------------------------------------------------------------
def Verifier_Fn(obj,A,nom,lien):

    VerifierNom(nom)

    nA=len(A)
    
    if nA != 3 :
        AfficherErreur([ " Fn = Fx,Fy,Fz"])
    

#---------------------------------------------------------------------------------------------------------------
def Verifier_Fnx(obj,A,nom,lien):
    Verifier_Fn1(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_Fny(obj,A,nom,lien):
    Verifier_Fn1(obj,A,nom,lien)
    
#---------------------------------------------------------------------------------------------------------------
def Verifier_Fnz(obj,A,nom,lien):
    Verifier_Fn1(obj,A,nom,lien)
    
    
#---------------------------------------------------------------------------------------------------------------
def Verifier_Fn1O(obj,A,nom,lien):

    VerifierNom(nom)

    nA=len(A)
    
    if nA not in [2,3] :
        AfficherErreur([ " Fn_ = A,Freq,Phase : nom"])  
    
#---------------------------------------------------------------------------------------------------------------
def Verifier_FnO(obj,A,nom,lien):

    nA=len(A)
    
    if nA  not in [4,5] :
        AfficherErreur([ " Fn = Fx,Fy,Fz,Freq : nom"])
    

#---------------------------------------------------------------------------------------------------------------
def Verifier_FnxO(obj,A,nom,lien):
    Verifier_Fn1O(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_FnyO(obj,A,nom,lien):
    Verifier_Fn1O(obj,A,nom,lien)
    
#---------------------------------------------------------------------------------------------------------------
def Verifier_FnzO(obj,A,nom,lien):
    Verifier_Fn1O(obj,A,nom,lien) 

#---------------------------------------------------------------------------------------------------------------
def Verifier_FreqMax(obj,A,nom,lien):

    nA=len(A)
    
    if nA  not in [1] :
        AfficherErreur([ "FreqMax=f"])

#---------------------------------------------------------------------------------------------------------------
def Verifier_GL(obj,A,nom,lien):
    Verifier_CG(obj,A,nom,lien)
    
#-------------------------------------------------------------------------------
def Verifier_Hc(obj,A,nom,lien):

    VerifierNom(nom)
    
    nA=len(A)

    if nA != 3 :
        AfficherErreur([    " Hc = r,h,n",
                            " où r : le rayon du cylindre",
                            "    h : le pas",
                            "    n : le nombre de tours" ])

    [r,h,n]=ConvNFloat(A,3)
    
    if r < 0 : 
        AfficherErreur([" Hc = r,h,n => r<0!"])
        
    if h < 0 : 
        AfficherErreur([" Hc = r,h,n => h<0!"])
        
    if n < 0 : 
        AfficherErreur([" Hc = r,h,n => n<0!"])        
    
    hb=h/2/math.pi
    Rc=(r*r+hb*hb)/r 
    d=1-4*pow(hb/Rc,2)
    if d < 0 :  AfficherErreur([" Valeur de h incohérente avec celle de r dans Hc"])
 

#-------------------------------------------------------------------------------
def Verifier_Lis(obj,A,nom,lien):

    nA=len(A)

    if nA != 0 or nom=="":
        AfficherErreur(["Li:nom"])
      
        
#-------------------------------------------------------------------------------
def Verifier_LgElement(obj,A,nom,lien):

    nA=len(A)

    if nA != 1 or nom!="": AfficherErreur(["LgElement = L"])

             
#-------------------------------------------------------------------------------
def Verifier_Lyre(obj,A,nom,lien):

    nA=len(A)
    
    if nom == "":
        AfficherErreur(" La commande CouleA a besoin d'un nom")
    
    if nA != 5 :
        AfficherErreur([ " Lyre = L,Ly,dL,rc,ad :nom"])
    
    [L,Ly,dL,rc,ad]=A
    
    if dL<2.01*rc:
        AfficherErreur(["Espace insuffisant entre les 2 coudes!"]) 
        
    if (dL+2*rc)*1.05>L:
        AfficherErreur(["Espace trop important!"]) 
  
  
#-------------------------------------------------------------------------------
def Verifier_Mn(obj,A,nom,lien):

    nA=len(A)
    
    if nA not in [3] :
        AfficherErreur([ " M = Mx,My,Mz:nom"])
  
#-------------------------------------------------------------------------------
def Verifier_MnO(obj,A,nom,lien):

    nA=len(A)
    
    if nA not in [4,5] :
        AfficherErreur([ " M = Mx,My,Mz,Freq,phase:nom"])

#-------------------------------------------------------------------------------
def Verifier_Mn1(obj,A,nom,lien):

    nA=len(A)
    
    if nA != 1 :
        AfficherErreur([ " M_ = A : nom, (nom facultatif)"])
        
#-------------------------------------------------------------------------------
def Verifier_Mn1O(obj,A,nom,lien):

    nA=len(A)
    
    if nA not in [2,3]:
        AfficherErreur([ " M_ = Amp, Freq, Phase : nom, (nom facultatif)"])
   

#-------------------------------------------------------------------------------
def Verifier_Maillage(obj,A,nom,lien):

    nA=len(A)
    
    if nA != 0 : AfficherErreur([ " Maillage:nom"])

    if nom not in ["LIN","QUAD"]: 
        AfficherErreur([ " Maillage:nom",
                        " avec nom = LIN ou QUAD"])
    
#-------------------------------------------------------------------------------
def Verifier_Masse(obj,A,nom,lien):

    nA=len(A)
    
    if nA != 1 :
        AfficherErreur([ " Masse=m:nom"])
    
    m=float(A[0])
    if m<0:
        AfficherErreur([ " m doit être positif"])

 
#-------------------------------------------------------------------------------
def Verifier_Mat(obj,A,nom,lien):

    if nom not in obj.DicMat:
        AfficherErreur([ nom + " : matériau inconnu"])


#-------------------------------------------------------------------------------
def Verifier_Model(obj,A,nom,lien):

    nA=len(A)
    
    if nA!=0 : AfficherErreur(["Model:type"])

    LesModeles=[
    "RESSORT",
    "TUBE",
    "3D",
    "CABLE",
    "BARRE",
    "TUYAU3M",
    "TUYAU6M",
    "POUTRE_RECTANGLE",
    "POUTRE"
    ]
    
    if nom not in LesModeles:
        AfficherErreur([ "Type de modèle inconnu"])   
        
    obj.iModel=True  
    obj.model = nom
    
#-------------------------------------------------------------------------------
def Verifier_Mnx(obj,A,nom,lien):
    Verifier_Mn1(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_Mny(obj,A,nom,lien):
    Verifier_Mn1(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_Mnz(obj,A,nom,lien):
    Verifier_Mn1(obj,A,nom,lien)
    
#--------------------------------------------------------------------------------------------------------------
def Verifier_MnxO(obj,A,nom,lien):
    Verifier_Mn1O(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_MnyO(obj,A,nom,lien):
    Verifier_Mn1O(obj,A,nom,lien)

#---------------------------------------------------------------------------------------------------------------
def Verifier_MnzO(obj,A,nom,lien):
    Verifier_Mn1O(obj,A,nom,lien)


#---------------------------------------------------------------------------------------------------------------
def Verifier_NbElement(obj,A,nom,lien):

    nA=len(A)

    if nA != 1 :
        AfficherErreur([  "  il faut 1 argument: NbElement=n"])

#---------------------------------------------------------------------------------------------------------------
# NP : Création de N point autour d'un point suivant Vd2x
def Verifier_NP(obj,A,nom,lien):

    nA=len(A)
    if nA not in [2,3]  or nom == "":
        AfficherErreur(["NP = N,L,a,u : nom "])

#---------------------------------------------------------------------------------------------------------------
def Verifier_P(obj,A,nom,lien):
    if not(obj.iModel):
        AfficherErreur([  "Il faut definir au moins une fois la commande Model !"])
    nA=len(A)
    if nA != 3 :
        AfficherErreur([  " il faut 3 arguments pour la commande P."])

#---------------------------------------------------------------------------------------------------------------
def Verifier_PF(obj,A,nom,lien):
    
    VerifierSupport(obj,"PF",A,nom)

#---------------------------------------------------------------------------------------------------------------
def Verifier_Pc(obj,A,nom,lien):

    nA=len(A)

    if nA != 1 :
        AfficherErreur([  "  il faut 1 argument, le nom étant facultatif : Pc=L:nom."])

#-------------------------------------------------------------------------------
def Verifier_Pd(obj,A,nom,lien):
    nA=len(A)
    if nA != 3 :
        AfficherErreur([ " il faut 3 arguments, le nom étant facultatif : Pd=L,ad,bd: nom"])
        

#---------------------------------------------------------------------------------------------------------------
def Verifier_Piq(obj,A,nom,lien):


    nA=len(A)
    if nA not in [5,6] :
        AfficherErreur([    "en 3D :  Piq=Rp,ep,ad1,ad2,rc,n",
                            "où:",
                            "Rp,ep :  Rayon et épaisseur du piquage",
                            "rc : rayon de courbure du cordon de soudure",
                            "ad1, ad2 : Angles dihédriques indiquant la direction du piquage",
                            "n : nombre d'éléments dans l'épaisseur"])
    else:
        [Rp,ep,r,ad1,ad2,n]=ConvNFloat(A,6)
        
    if nom == "":
    
        AfficherErreur([        "ligne "+ str(i) + " :Les piquages doivent toujours être nommés pour pouvoir être utilisés."])
        

    [Rc,ec]=obj.secx

    if Rp > Rc :
        AfficherErreur(["Le diamètre du piquage doit être inférieur à celui du collecteur!"])        

    if ep > Rp/4:
        AfficherErreur(["L'épaisseur des tuyaux doit être inférieure à R/4!"]) 

   


#-------------------------------------------------------------------------------
def Verifier_Press(obj,A,nom,lien):
    nA=len(A)
    if nA != 1 :
        AfficherErreur([ "  Pres=p"])



#--------------------------------------------------------------------------------------------------------------
def Verifier_PVcPxK(A,nom,lien):

    nA = len(A)
    if nA != 1  or nom=="":
        AfficherErreur(["VcPx=L:Px,nom"])
        
        
#---------------------------------------------------------------------------------------------------------------
def Verifier_Px(obj,A,nom,lien):

    if A != [] or nom == "":
  
        AfficherErreur(["Px:nom"])
   
#---------------------------------------------------------------------------------------------------------------
def Verifier_Pxv(obj,A,nom,lien):

    nA=len(A)

    if nA!=0 or nom == "":  AfficherErreur(["Pxvr:nom"]) 
   
            
#---------------------------------------------------------------------------------------------------------------
def Verifier_Pxvr(obj,A,nom,lien):

    nA=len(A)

    if nA!=0 or nom == "":  AfficherErreur(["Pxvr:nom"])
   
#---------------------------------------------------------------------------------------------------------------
def Verifier_Raideur(obj,A,nom,lien):

    nA=len(A)

    if nA != 1 or nom != "":  AfficherErreur(["Raideur=K"])

#---------------------------------------------------------------------------------------------------------------
def Verifier_Relier(obj,A,nom,lien):

    nA=len(A)

    tex = "Relier=Rc,h:B"
    if nA != 2:
        AfficherErreur([tex])

    if "," in nom:
        AfficherErreur([tex])   
    
    [Rc,h] = VectNum(A)
    if  Rc < eps or h < eps:
        AfficherErreur([tex +" : Le rayon de courbure  et la distance h doivent être positif "])   
          
          
          
#---------------------------------------------------------------------------------------------------------------          
def Verifier_Repere(obj,A,nom,lien):

    nA=len(A)

    if nA != 1 :
        if A not in ["LOCAL","GLOBAL"]:
            AfficherErreur(["ligne ", i, " : Repere = LOCAL ou GLOBAL"])


#---------------------------------------------------------------------------------------------------------------
def Verifier_RhoV(obj,A,nom,lien):

    nA=len(A)


    if nA != 1 :
        AfficherErreur(["il faut 1 valeur pour caractériser la masse volumique du contenu."])

    if float(A[0])<eps*-1:
        AfficherErreur(["Erreur : la densité du contenu doit être positive ou nulle"])



#---------------------------------------------------------------------------------------------------------------
# Changement de section avec :
#   - evolution parabolique du rayon
#   - évolution linéaire de l'épaisseur
def Verifier_ScPar(obj,A,nom,lien):
    
    if obj.forme != "ROND" : AfficherErreur(["Changement de section uniquement possible avec une section ROND"])    
    
    [R,e,L,N] = ConvNFloat(A,4)
    obj.secx = [R,e]
    nA=len(A)

    if  not(nA in [3,4]) :
        AfficherErreur([        " il faut 3 arguments pour la commande ScPar: ScPar=R,e,L,N",
                                "  où ",
                                "     R, e : Rayon et épaisseur finale",
                                "     L : Longueur de la partie parabolique",
                                "     N : nombre de découpage"
                       ])


#---------------------------------------------------------------------------------------------------------------
def Verifier_Sc(obj,A,nom,lien):
    
    if obj.forme != "ROND" : AfficherErreur(["Changement de section uniquement possible avec une section ROND"])
 
    nA=len(A)

    if  nA != 3 :
        AfficherErreur([" il faut 3 arguments pour la commande Sc: Sc=r,e,L"])

    obj.secx=VectNum(A[:2])
    [R,e]=obj.secx
    
    if R < 0:
        AfficherErreur([ "Le rayon de la section doit être positif !"])
    
    if e < 0:
        AfficherErreur(["L'épaisseur de la section doit être positif !"])
        
    if e > R:
        AfficherErreur(["Erreur épaisseur > Rayon !"])
        
    if R/e > 50 : AfficherErreur(["Le rapport D/e doit être inférieur à 100"])


#-------------------------------------------------------------------------------
def Verifier_Sce(obj,A,nom,lien):
    
    if obj.forme != "ROND" : AfficherErreur(["Changement de section uniquement possible avec une section ROND"])
 
    nA=len(A)

    if  nA not in [3,4] :
        AfficherErreur([" il faut 3 ou 5 arguments pour la commande Sce : Sce=r,e,L,ad"])

    obj.secx=VectNum(A[:2])
    [R,e]=obj.secx
    
    if R < 0:
        AfficherErreur([ "Le rayon de la section doit être positif !"])
    
    if e < 0:
        AfficherErreur(["L'épaisseur de la section doit être positif !"])
        
    if e > R:
        AfficherErreur(["Erreur épaisseur > Rayon !"])   
        
    if R/e > 50 : Afficher(["Le rapport D/e doit être inférieur à 100"])
    
  
 
#-------------------------------------------------------------------------------
def Verifier_Section(obj,A,nom,lien):
    
    nA=len(A)
    
    if nA!=0 or nom=="" or obj.model!="POUTRE": 
        AfficherErreur([
        "Section s'utilise avec le modèle POUTRE",
        "Section:nom",
        ])
    
    try:
        obj.section=LesSections[nom]
    except:
        AfficherErreur([
        "Section inconnue",
        ])
        
    
#-------------------------------------------------------------------------------
def Verifier_Si(obj,A,nom,lien):

    nA=len(A)

    if obj.model in ["BARRE","TUBE","TUYAU3M","TUYAU6M","RESSORT"]:    

        if not(nA in [2]):
            AfficherErreur(["Il faut donner :   Si=R,r"])

        [R,e]=ConvNFloat(A,2)
        if e==0 : e=R

        if R < 0:
            AfficherErreur(["Le rayon de la section doit être positif !"])
        
        if e < 0:
            AfficherErreur(["L'épaisseur de la section doit être positif !"])
            
        if e> R:
            AfficherErreur(["Erreur épaisseur > Rayon !"])
            
        if R/e > 50 : Afficher(["Le rapport D/e doit être inférieur à 100"])
            
        obj.secx = [R,e]

    elif obj.model in ["CABLE"]:

        if not(nA in [1]):
            AfficherErreur([" Pour un CABLE il faut donner  la valeur de sa section"])

        [S]=ConvNFloat(A,1)    
        
        R=sqrt(S/math.pi)
        obj.secx=[R,R]
        
    elif obj.model in ["POUTRE_RECTANGLE"]:
        if not(nA in [2,3,4]):
            AfficherErreur([
            " Pour une poutre rectangulaire,",
            " il faut donner  les valeurs suivantes Si = Hy,Hz,ey,ez",
            ])
        [Hy,Hz,ey,ez]=ConvNFloat(A,4)
        if ez==0:ez=ey
        if Hy < 2*ey or Hz < 2*ez:
            AfficherErreur(["Valeurs de la section incohérentes"])
            
    else:
        AfficherErreur([
        "Affectation non définie pour ce type de modèle",
        ])
        


        
#--------------------------------------------------------------------------------------------------------------
def Verifier_Table(obj,A,nom,lien):
    nA=len(A) 
    # TODO add check for Table    
    #if nA != 3:
    #    AfficherErreur([" Table: nomChamp,nomComposante,nomTableau"])
   
   
#--------------------------------------------------------------------------------------------------------------
def Verifier_Te(obj,A,nom,lien):
    nA=len(A)  
    
    if nA!= 5 : AfficherErreur(["Te=Rp,ep,ad,Lc,Lp:nom"])
    
    [Rp,ep,ad,Lc,Lp]=ConvNFloat(A,5)
    
    [Rc,ec]=obj.secx
    
    if Rp>Rc*1.0001 : AfficherErreur(["Rp doit être inférieur à Rc"])

#--------------------------------------------------------------------------------------------------------------
def Verifier_Temp(obj,A,nom,lien):

    nA=len(A) 
 
    if nA not in [0,1] or (nA == 0 and nom != "FIN"):
        AfficherErreur([" Temp = T  ou Temp : FIN"]) 



#--------------------------------------------------------------------------------------------------------------
def Verifier_Tore(obj,A,nom,lien):

    nA=len(A)
    if nA != 2 :
        AfficherErreur(["Tore=R,N avec R:rayon du tore et N:nombre de découpage"])
        
#--------------------------------------------------------------------------------------------------------------
def Verifier_Unite(obj,A,nom,lien):

    nA=len(A)
    if nA != 0 or nom not in ["mm","m","km"]:
        AfficherErreur(["Unite:m ou mm ou km"])
            


#---------------------------------------------------------------------------------------------------------------
def Verifier_VPiq(obj,A,nom,lien):

    nA=len(A)

    if nA not in [3,4,5] :
        AfficherErreur([    "en TUBE : Piq=Rp,ep,ad1,ad2,rc"
                            "où:",
                            "Rp,ep :  Rayon et épaisseur du piquage",
                            "rc : rayon de courbure du cordon de soudure",
                            "ad1, ad2 : Angles dihédriques indiquant la direction du piquage (=0 par défaut)"])

    [Rp,ep,ad1,rc,ad2] =  ConvNFloat(A,5)
    if nom == "":
        AfficherErreur([    "Les piquages doivent toujours être nommés "])  

    [Rc,ec]=obj.secx

    if Rp > Rc :
        AfficherErreur([    "Le diamètre du piquage doit être inférieur à celui du collecteur!"])        

    if ep > Rp/4:
        AfficherErreur([    "L'épaisseur des tuyaux doit être inférieure à R/4!"]) 
        
#---------------------------------------------------------------------------------------------------------------
def Verifier_VPoq(obj,A,nom,lien):

    nA=len(A)

    if nA not in [3,4,5,6] :
        AfficherErreur([    "en TUBE : Piq=Rc,ec,ad1,ad2,rc,Lc"
                            "où:",
                            "Rc,ec :  Rayon et épaisseur du piquage",
                            "rc : rayon de courbure du cordon de soudure",
                            "ad1, ad2 : Angles dihédriques indiquant la direction du piquage (=0 par défaut)",
                            "Lc : longueur du T"])
    [Rc,ec,ad1,rc,ad2,Lc] =  ConvNFloat(A,6)
    [Rp,ep]=obj.secx
    if nom == "":
        AfficherErreur([    "Les piquages doivent toujours être nommés "])  

    if Rp > Rc :
        AfficherErreur([    "Le diamètre du piquage doit être inférieur à celui du collecteur!"])        

    if ep > Rp/4:
        AfficherErreur([    "L'épaisseur des tuyaux doit être inférieure à R/4!"]) 
    obj.secx = [Rc,ec]


#---------------------------------------------------------------------------------------------------------------
def Verifier_VPx(obj,A,nom,lien):

    nA = len(A)
    if nA != 0 or nom == "":
        AfficherErreur(["VPx:nom"])


#--------------------------------------------------------------------------------------------------------------
def Verifier_V(obj,A,nom,lien):

    nA=len(A)

    if nA != 3 :
        AfficherErreur([" il faut 3 argument pour la commande V."])

#--------------------------------------------------------------------------------------------------------------
def Verifier_Vanne(obj,A,nom,lien):

    nA=len(A)

    if not(nA in [1,2,3,4]): 
        AfficherErreur([    " Vanne=L,m,h,ad",
                            "     L=Longueur",
                            "     m:masse",
                            "     h:Distance axe/centre de gravite",
                            "     ad:angle dihèdrique pour positionner le centre de gravité"])


#--------------------------------------------------------------------------------------------------------------
def Verifier_Var(obj,A,nom,lien):

    nA=len(A)
    if nA != 1 or nom == "":
        AfficherErreur([" V=x:L ou L est une lettre majuscule et x un réel"])


#--------------------------------------------------------------------------------------------------------------
def Verifier_VcPx(obj,A,nom,lien):

    nA = len(A)
    if nA != 1  or nom=="":
        AfficherErreur(["VcPx=L:Px,nom)"])
            
  
#---------------------------------------------------------------------------------------------------------------
def Verifier_Vc(obj,A,nom,lien):

    nA=len(A)
    if nA not in [1] :
        AfficherErreur([    "Vc=L où L=longueur"])
   
    
#--------------------------------------------------------------------------------------------------------------
def Verifier_Vd(obj,A,nom,lien):
    
    nA=len(A)

    if nA<1 or nA >= 4 :
        AfficherErreur([" il faut au maximum 1 à 3 arguments avec Vd=D,ad,bd"])

    if A[0] < eps :
        AfficherErreur([" Vd = D,ad,bd avec D>0"])

#--------------------------------------------------------------------------------------------------------------
def Verifier_Vd1x(obj,A,nom,lien):
    
    nA=len(A)
    
    if nA != 3 :
        AfficherErreur([" Vd1x nécessite 3 valeurs, (1er vecteur dihédre qui n'apparait pas)"])
    
    #obj.Vd1x = VectNum(A) (done in conver_vd1x)

#--------------------------------------------------------------------------------------------------------------
def Verifier_Vd2x(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 3 :
        AfficherErreur([" Vd2x nécessite 3 valeurs  (2ème vecteur dihédre qui n'apparait pas)"])
    #obj.Vd2x = VectNum(A)  (done in conver_vd1x)


#--------------------------------------------------------------------------------------------------------------
def Verifier_WireVc(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 1 : AfficherErreur([" Wire2Dc nécessite 1 valeurs dans A et une description du wire entre []"])
#--------------------------------------------------------------------------------------------------------------
def Verifier_Wire(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 3 : AfficherErreur([" Wire2D nécessite 3 valeurs dans A et une description du wire entre []"])


#--------------------------------------------------------------------------------------------------------------
def Verifier_Wire2Dc(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 1 : AfficherErreur([" Wire2D nécessite 1 valeurs dans A et une description du wire entre []"])

#--------------------------------------------------------------------------------------------------------------
def Verifier_Wire2D(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 3 : AfficherErreur([" Wire2D nécessite 3 valeurs dans A et une description du wire entre []"])

        
#--------------------------------------------------------------------------------------------------------------
def Verifier_Wire2Ds(obj,A,nom,lien):
    
    nA=len(A)

    if nA != 3 : AfficherErreur([" Wire2D nécessite 3 valeurs dans A et une description du wire entre []"])

#--------------------------------------------------------------------------------------------------------------
def Verifier_g(obj,A,nom,lien):

    nA=len(A)

    if nA != 3 :
        AfficherErreur(["g=gx,gy,gz'"])

